package org.example.scoresystem_backen.controller;

import org.example.scoresystem_backen.common.Result;
import org.example.scoresystem_backen.dto.AdminDTO;
import org.example.scoresystem_backen.dto.AuthResponse;
import org.example.scoresystem_backen.dto.PageResponse;
import org.example.scoresystem_backen.entity.Admin;
import org.example.scoresystem_backen.service.AdminService;
import org.example.scoresystem_backen.util.AuthUtil;
import org.example.scoresystem_backen.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * 管理员控制器
 */
@RestController
@RequestMapping("/api/admin")
@CrossOrigin(origins = "*")
public class AdminController {

    @Autowired
    private AdminService adminService;

    @Autowired
    private JwtUtil jwtUtil;


    /**
     * 管理员登录
     * @param loginRequest 登录请求
     * @return 登录结果（包含JWT令牌）
     */
    @PostMapping("/login")
    public Result<AuthResponse> login(@RequestBody Map<String, String> loginRequest) {
        try {
            String username = loginRequest.get("username");
            String password = loginRequest.get("password");
            Admin admin = adminService.login(username, password);

            // 根据管理员角色生成对应的userType
            String userType;
            switch (admin.getRole()) {
                case SUPER_ADMIN:
                    userType = "super_admin";
                    break;
                case ADMIN:
                    userType = "admin";
                    break;
                default:
                    userType = "admin"; // 默认为普通管理员
                    break;
            }

            // 生成JWT令牌
            String token = jwtUtil.generateToken(admin.getId(), admin.getUsername(), userType);

            // 创建认证响应
            AuthResponse authResponse = new AuthResponse(
                token,
                admin.getId(),
                admin.getUsername(),
                userType,
                admin.getUsername()
            );

            return Result.success("登录成功", authResponse);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 创建管理员
     * @param admin 管理员信息
     * @return 创建结果
     */
    @PostMapping
    public Result<AdminDTO> createAdmin(@RequestBody Admin admin) {
        try {
            // 权限检查：只有超级管理员可以创建管理员
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            Admin createdAdmin = adminService.createAdmin(admin);
            AdminDTO adminDTO = AdminDTO.fromEntity(createdAdmin);
            return Result.success("创建成功", adminDTO);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 更新管理员信息
     * @param id 管理员ID
     * @param admin 管理员信息
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result<AdminDTO> updateAdmin(@PathVariable Integer id, @RequestBody Admin admin) {
        try {
            // 权限检查：只有超级管理员可以更新管理员信息
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            admin.setId(id);
            Admin updatedAdmin = adminService.updateAdmin(admin);
            AdminDTO adminDTO = AdminDTO.fromEntity(updatedAdmin);
            return Result.success("更新成功", adminDTO);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 删除管理员
     * @param id 管理员ID
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Void> deleteAdmin(@PathVariable Integer id) {
        try {
            // 权限检查：只有超级管理员可以删除管理员
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 防止删除自己
            if (currentUserId.equals(id)) {
                return Result.error("不能删除自己的账户");
            }

            adminService.deleteAdmin(id);
            return Result.success("删除成功");
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据ID查找管理员
     * @param id 管理员ID
     * @return 管理员信息
     */
    @GetMapping("/{id}")
    public Result<Admin> findById(@PathVariable Integer id) {
        try {
            Admin admin = adminService.findById(id);
            return Result.success(admin);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 获取管理员列表（分页查询）
     * 支持搜索和角色过滤
     *
     * @param page 页码，从1开始
     * @param pageSize 每页大小
     * @param search 搜索关键词（用户名模糊查询）
     * @param role 角色过滤（0-学生，1-管理员，2-超级管理员）
     * @return 管理员分页数据
     */
    @GetMapping
    public Result<PageResponse<AdminDTO>> getAdmins(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10", name = "page_size") Integer pageSize,
            @RequestParam(required = false) String search,
            @RequestParam(required = false) String role) {
        try {
            // 权限检查：只有超级管理员可以访问管理员管理
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 这里可以添加更严格的权限检查，比如检查当前用户是否为超级管理员
            // 暂时简化处理，允许所有已登录用户访问

            org.example.scoresystem_backen.dto.PageRequest pageRequest = new org.example.scoresystem_backen.dto.PageRequest();
            pageRequest.setPage(page);
            pageRequest.setPageSize(pageSize);
            pageRequest.setSearch(search);

            // 处理角色过滤
            if (role != null && !role.isEmpty()) {
                pageRequest.setSearch("role:" + role);
            }

            PageResponse<AdminDTO> response = adminService.findAdminsByPage(pageRequest);
            return Result.success("查询成功", response);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据用户名模糊查询管理员
     * @param username 用户名关键字
     * @return 管理员列表
     */
    @GetMapping("/search")
    public Result<List<Admin>> searchByUsername(@RequestParam String username) {
        try {
            List<Admin> admins = adminService.findByUsernameContaining(username);
            return Result.success(admins);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 修改密码
     * @param passwordRequest 密码修改请求
     * @return 修改结果
     */
    @PostMapping("/change-password")
    public Result<Void> changePassword(@RequestBody Map<String, Object> passwordRequest) {
        try {
            Integer id = (Integer) passwordRequest.get("id");
            String oldPassword = (String) passwordRequest.get("oldPassword");
            String newPassword = (String) passwordRequest.get("newPassword");
            adminService.changePassword(id, oldPassword, newPassword);
            return Result.success("密码修改成功");
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
}
